﻿#define  _CRT_SECURE_NO_WARNINGS 1

//5.函数重载
//#include <iostream>
//using namespace std;
//
////1、参数类型不同
//int Add(int x, int y)
//{
//	cout << "Add(int x, int y)" << endl;
//
//	return x + y;
//}
//
//double Add(double x, double y)
//{
//	cout << "Add(double x, double y)" << endl;
//
//	return  x + y;
//}
//
////2、参数个数不同
//void f()
//{
//	cout << "f()" << endl;
//}
//
//void f(int a)
//{
//	cout << "f(int a)" << endl;
//}
//
//// 3、参数类型顺序不同
//void f(int a, char b)
//{
//	cout << "f(int a, char b)" << endl;
//}
//
//void f(char b, int a)
//{
//	cout << "f(char b, int a)" << endl;
//}
//
//int main()
//{
//	Add(10, 20);
//	Add(10.1, 20.2);
//
//	f();
//	f(10);
//
//	f(10, 'a');
//	f('a', 10);
//
//	return 0;
//}


//6.引用
//#include <iostream>
//using namespace std;
//#include <cstdio>
////
//void TestRef1()
//{
//	int a = 10;
//	int& ra = a;//定义引用类型
//
//	printf("%p\n", &a);
//	printf("%p\n", &ra);
//}
////6.2 引用特性
//void TestRef2()
//{
//	int a = 10;
//	//int& ra; //该语句编译时会出错，引用在定义时必须初始化
//	int& ra = a;
//	int& rra = a;
//	
//	printf("%p %p %p\n", &a, &ra ,&rra);
//}
////6.3 常引用
//void TestConstRef()
//{
//	const int a = 10;
//	
//	//int& ra = a; 该语句编译时会出错，a为常量 
//	const int& ra = a;
//	//int& b = 10;该语句编译时会出错，b为常量
//	const int& b = 10;
//	double d = 12.34;
//	//int& rd = d; 该语句编译时会出错，类型不同
//	//const int& rd = d;
//}
//
////6.4 使用场景
////1. 做参数
//void Swap(int& x, int& y)
//{
//	int tmp = x;
//	 x = y;
//	 y = tmp;
//}
//
////2. 做返回值
//int& Count()
//{
//	static int n = 0;
//	n++;
//	//...
//	return n;
//}
//
//int& Add(int a, int b)
//{
//	int c = a + b;
//	return c;
//}
//int main()
//{
//	//TestRef1();
//	//TestRef2();
//	//TestConstRef();
//
//	int& ret = Add(1, 2);
//	//Add(3, 4);
//	cout << "Add(1, 2) is :" << ret << endl;
//	return 0;
//}



//#include <time.h>
//#include <iostream>
//using namespace std;
//struct A
//{
//	int a[10000];
//};
//
//void TestFunc1(A a)
//{
//
//}
//
//void TestFunc2(A& a)
//{
//
//}
//
//void TestRefAndValue()
//{
//	A a;
//	//以值作为函数参数
//	size_t begin1 = clock();
//	for (size_t i = 0; i < 10000; ++i)
//		TestFunc1(a);
//	size_t end1 = clock();
//
//	//以引用作为函数参数
//	size_t begin2 = clock();
//	for (size_t i = 0; i < 10000; ++i)
//		TestFunc2(a);
//	size_t end2 = clock();
//
//	//分别计算两个函数运行结束后的时间
//	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
//	cout << "TestFunc1(A&)-time:" << end2 - begin2 << endl;
//
//}
//
//int main()
//{
//	TestRefAndValue();
//	return 0;
//}

//6.5.2 值和引用的作为返回值类型的性能比较
//#include <time.h>
//#include <iostream>
//using namespace std;
//struct A
//{
//	int a[10000];
//};
//A a;
//// 值返回
//A TestFunc1() 
//{ 
//	return a; 
//}
//// 引用返回
//A& TestFunc2() 
//{
//	return a;
//}
//void TestReturnByRefOrValue()
//{
//	// 以值作为函数的返回值类型
//	size_t begin1 = clock();
//	for (size_t i = 0; i < 100000; ++i)
//		TestFunc1();
//	size_t end1 = clock();
//	// 以引用作为函数的返回值类型
//	size_t begin2 = clock();
//	for (size_t i = 0; i < 100000; ++i)
//		TestFunc2();
//	size_t end2 = clock();
//	// 计算两个函数运算完成之后的时间
//	cout << "TestFunc1 time:" << end1 - begin1 << endl;
//	cout << "TestFunc2 time:" << end2 - begin2 << endl;
//}
//
//int main()
//{
//	int a = 10;
//	int& ra = a;
//	cout << "&a = " << &a << endl;
//	cout << "&ra = " << &ra << endl;
//	return 0;
//}


//inline int Add(int x, int y)
//{
//	return x + y;
//}
//int main()
//{
//	Add(1, 2);
//	int a = 10;
//
//	int& ra = a;
//	ra = 20;
//
//	int* pa = &a;
//	*pa = 20;
//
//	return 0;
//}

//8.auto 关键字
//#include <iostream>
//using namespace std;
//
//int TestAuto()
//{
//	return 10;
//}
//
//int main()
//{
//	int a = 10;
//	auto b = a;
//	auto c = 'a';
//	auto d = TestAuto();
//	cout << typeid(b).name() << endl;
//	cout << typeid(c).name() << endl;
//	cout << typeid(d).name() << endl;
//
//	//auto e; //无法通过编译，使用auto定义变量时必须对其进行初始化
//	return 0;
//}

//8.3 auto的使用细则
//1.与指针和引用结合起来使用
//#include <iostream>
//using namespace std;
//int main()
//{
//	int x = 10;
//	auto a = &x;
//	auto* b = &x;
//	auto& c = x;
//
//	cout << typeid(a).name() << endl;
//	cout << typeid(b).name() << endl;
//	cout << typeid(c).name() << endl;
//
//	*a = 20;
//	*b = 30;
//	c = 40;
//
//	return 0;
//}

////2. 在同一行定义多个变量
//void TestAuto()
//{
//	auto a = 1, b = 2;
//	auto c = 3, d = 4.0; //该行代码会编译失败，因为c和d的初始化表达式类型不同
//}

//8.4 auto不能推导的场景
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
//void TestAuto(auto a)
//{}

//void TestAuto()
//{
//	int a[] = { 1,2,3,4 };
//	auto b[] = { 3,4,5 };
//}

void TestFor()
{
	int array[] = { 1,2,3,4,5 };
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
		array[i] *= 2;

	for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
		cout << *p << endl;
}
#include <iostream>	
using namespace std;
void TestFor2()
{
	int array[] = { 1,2,3,4,5 };
	for (auto& e : array)
		e *= 2;
	for (auto e : array)
		cout << e << " ";
}
int main()
{
	TestFor2();
	return 0;
}